'use strict';

const Controller = require('egg').Controller;
const SupplierService = require('../../service/procurement/supplier_service');

class SupplierController extends Controller {
  
  // 获取供应商列表 (对应路由中的 index)
  async index() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const result = await supplierService.getSupplierList(ctx.query);
      // 重新组织返回的数据结构，确保stats字段正确
      ctx.page(result.list, result.pagination.total, result.pagination.page, result.pagination.limit);
    } catch (error) {
      ctx.logger.error('获取供应商列表失败:', error);
      ctx.error(error.message || '获取供应商列表失败');
    }
  }
  
  // 获取供应商详情 (对应路由中的 show)
  async show() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    const { id } = ctx.params;
    
    try {
      const supplier = await supplierService.getSupplierById(id);
      ctx.success(supplier);
    } catch (error) {
      ctx.logger.error('获取供应商详情失败:', error);
      ctx.error(error.message || '获取供应商详情失败');
    }
  }
  
  // 创建供应商 (对应路由中的 create)
  async create() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const supplierData = ctx.request.body;
      
      // 设置组织ID
      if (ctx.state.organizationId) {
        supplierData.organizationId = ctx.state.organizationId;
      } else {
        supplierData.organizationId = 1; // 默认组织ID
      }
      
      const supplier = await supplierService.createSupplier(supplierData);
      ctx.success(supplier, '供应商创建成功');
    } catch (error) {
      ctx.logger.error('创建供应商失败:', error);
      ctx.error(error.message || '创建供应商失败');
    }
  }
  
  // 更新供应商 (对应路由中的 update)
  async update() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    const { id } = ctx.params;
    
    try {
      const supplier = await supplierService.updateSupplier(id, ctx.request.body);
      ctx.success(supplier, '供应商更新成功');
    } catch (error) {
      ctx.logger.error('更新供应商失败:', error);
      ctx.error(error.message || '更新供应商失败');
    }
  }
  
  // 删除供应商 (对应路由中的 destroy)
  async destroy() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    const { id } = ctx.params;
    
    try {
      await supplierService.deleteSupplier(id);
      ctx.success(null, '供应商删除成功');
    } catch (error) {
      ctx.logger.error('删除供应商失败:', error);
      ctx.error(error.message || '删除供应商失败');
    }
  }
  
  // 批量删除供应商 (对应路由中的 batchDelete)
  async batchDelete() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const { ids } = ctx.request.body;
      const message = await supplierService.batchDeleteSuppliers(ids);
      ctx.success(null, message);
    } catch (error) {
      ctx.logger.error('批量删除供应商失败:', error);
      ctx.error(error.message || '批量删除供应商失败');
    }
  }
  
  // 批量激活供应商 (对应路由中的 batchActivate)
  async batchActivate() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const { ids } = ctx.request.body;
      const message = await supplierService.batchActivateSuppliers(ids);
      ctx.success(null, message);
    } catch (error) {
      ctx.logger.error('批量激活供应商失败:', error);
      ctx.error(error.message || '批量激活供应商失败');
    }
  }
  
  // 批量停用供应商 (对应路由中的 batchDeactivate)
  async batchDeactivate() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const { ids } = ctx.request.body;
      const message = await supplierService.batchDeactivateSuppliers(ids);
      ctx.success(null, message);
    } catch (error) {
      ctx.logger.error('批量停用供应商失败:', error);
      ctx.error(error.message || '批量停用供应商失败');
    }
  }
  
  // 导出供应商 (对应路由中的 exportSuppliers)
  async exportSuppliers() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const csvContent = await supplierService.exportSuppliers(ctx.query);
      
      // 设置响应头
      ctx.set('Content-Type', 'text/csv; charset=utf-8');
      ctx.set('Content-Disposition', 'attachment; filename=suppliers.csv');
      
      ctx.body = csvContent;
    } catch (error) {
      ctx.logger.error('导出供应商失败:', error);
      ctx.error(error.message || '导出供应商失败');
    }
  }
  
  // 导入供应商 (对应路由中的 importSuppliers)
  async importSuppliers() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      // 从ctx中获取文件和字段映射
      const files = ctx.request.files;
      let fieldMapping = {};
      
      // 获取字段映射关系
      if (ctx.request.body && ctx.request.body.fieldMapping) {
        try {
          fieldMapping = JSON.parse(ctx.request.body.fieldMapping);
          ctx.logger.info('字段映射关系:', fieldMapping);
        } catch (e) {
          ctx.logger.warn('解析字段映射关系失败:', e.message);
        }
      }
      
      // 如果接收到文件
      if (files && files.length > 0) {
        const file = files[0]; // 获取第一个文件
        ctx.logger.info('成功获取文件:', file.filename || file.name);
        
        // 调用服务层导入方法
        const result = await supplierService.importSuppliers(file, fieldMapping);
        
        // 检查连接是否仍然有效
        if (ctx.res.headersSent) {
          ctx.logger.warn('响应头已发送，客户端可能已断开连接');
          return;
        }
        
        ctx.success(result, `成功导入${result.importedCount}个供应商`);
      } else {
        // 如果没有接收到文件
        ctx.error('未找到上传的文件', 400);
      }
    } catch (error) {
      ctx.logger.error('导入供应商失败:', error);
      
      // 检查连接是否仍然有效
      if (ctx.res.headersSent) {
        ctx.logger.warn('响应头已发送，客户端可能已断开连接');
        return;
      }
      
      ctx.error(error.message || '导入供应商失败');
    }
  }
  
  // 导入供应商模板 (对应路由中的 exportTemplate)
  async exportTemplate() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const buffer = await supplierService.exportTemplate();
      
      // 设置响应头
      ctx.set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
      ctx.set('Content-Disposition', 'attachment; filename=supplier_import_template.xlsx');
      
      ctx.body = buffer;
    } catch (error) {
      ctx.logger.error('生成导入模板失败:', error);
      ctx.error(error.message || '生成导入模板失败');
    }
  }
  
  // 获取供应商统计信息
  async stats() {
    const { ctx } = this;
    const supplierService = new SupplierService(ctx);
    
    try {
      const stats = await supplierService.getSupplierStats();
      ctx.success(stats, '获取供应商统计信息成功');
    } catch (error) {
      ctx.logger.error('获取供应商统计信息失败:', error);
      ctx.error(error.message || '获取供应商统计信息失败');
    }
  }
}

module.exports = SupplierController;
